home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / lib / python2.6 / contextlib.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2009-11-11  |  4KB  |  169 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. '''Utilities for with-statement contexts.  See PEP 343.'''
  5. import sys
  6. from functools import wraps
  7. __all__ = [
  8.     'contextmanager',
  9.     'nested',
  10.     'closing']
  11.  
  12. class GeneratorContextManager(object):
  13.     '''Helper for @contextmanager decorator.'''
  14.     
  15.     def __init__(self, gen):
  16.         self.gen = gen
  17.  
  18.     
  19.     def __enter__(self):
  20.         
  21.         try:
  22.             return self.gen.next()
  23.         except StopIteration:
  24.             raise RuntimeError("generator didn't yield")
  25.  
  26.  
  27.     
  28.     def __exit__(self, type, value, traceback):
  29.         if type is None:
  30.             
  31.             try:
  32.                 self.gen.next()
  33.             except StopIteration:
  34.                 return None
  35.  
  36.             raise RuntimeError("generator didn't stop")
  37.         type is None
  38.         if value is None:
  39.             value = type()
  40.         
  41.         
  42.         try:
  43.             self.gen.throw(type, value, traceback)
  44.             raise RuntimeError("generator didn't stop after throw()")
  45.         except StopIteration:
  46.             exc = None
  47.             return exc is not value
  48.             if sys.exc_info()[1] is not value:
  49.                 raise 
  50.             sys.exc_info()[1] is not value
  51.  
  52.  
  53.  
  54.  
  55. def contextmanager(func):
  56.     '''@contextmanager decorator.
  57.  
  58.     Typical usage:
  59.  
  60.         @contextmanager
  61.         def some_generator(<arguments>):
  62.             <setup>
  63.             try:
  64.                 yield <value>
  65.             finally:
  66.                 <cleanup>
  67.  
  68.     This makes this:
  69.  
  70.         with some_generator(<arguments>) as <variable>:
  71.             <body>
  72.  
  73.     equivalent to this:
  74.  
  75.         <setup>
  76.         try:
  77.             <variable> = <value>
  78.             <body>
  79.         finally:
  80.             <cleanup>
  81.  
  82.     '''
  83.     
  84.     def helper(*args, **kwds):
  85.         return GeneratorContextManager(func(*args, **kwds))
  86.  
  87.     helper = (wraps(func),)(helper)
  88.     return helper
  89.  
  90.  
  91. def nested(*managers):
  92.     '''Support multiple context managers in a single with-statement.
  93.  
  94.     Code like this:
  95.  
  96.         with nested(A, B, C) as (X, Y, Z):
  97.             <body>
  98.  
  99.     is equivalent to this:
  100.  
  101.         with A as X:
  102.             with B as Y:
  103.                 with C as Z:
  104.                     <body>
  105.  
  106.     '''
  107.     exits = []
  108.     vars = []
  109.     exc = (None, None, None)
  110.     
  111.     try:
  112.         for mgr in managers:
  113.             exit = mgr.__exit__
  114.             enter = mgr.__enter__
  115.             vars.append(enter())
  116.             exits.append(exit)
  117.         
  118.         yield vars
  119.     except:
  120.         exc = sys.exc_info()
  121.     finally:
  122.         while exits:
  123.             exit = exits.pop()
  124.             
  125.             try:
  126.                 if exit(*exc):
  127.                     exc = (None, None, None)
  128.             continue
  129.             exc = sys.exc_info()
  130.             continue
  131.  
  132.         if exc != (None, None, None):
  133.             raise exc[0], exc[1], exc[2]
  134.         exc != (None, None, None)
  135.  
  136.  
  137. nested = contextmanager(nested)
  138.  
  139. class closing(object):
  140.     '''Context to automatically close something at the end of a block.
  141.  
  142.     Code like this:
  143.  
  144.         with closing(<module>.open(<arguments>)) as f:
  145.             <block>
  146.  
  147.     is equivalent to this:
  148.  
  149.         f = <module>.open(<arguments>)
  150.         try:
  151.             <block>
  152.         finally:
  153.             f.close()
  154.  
  155.     '''
  156.     
  157.     def __init__(self, thing):
  158.         self.thing = thing
  159.  
  160.     
  161.     def __enter__(self):
  162.         return self.thing
  163.  
  164.     
  165.     def __exit__(self, *exc_info):
  166.         self.thing.close()
  167.  
  168.  
  169.